23 research outputs found
The TTC 2013 Flowgraphs Case
This case for the Transformation Tool Contest 2013 is about evaluating the
scope and usability of transformation languages and tools for a set of four
tasks requiring very different capabilities. One task deals with typical
model-to-model transformation problem, there's a model-to-text problem, there
are two in-place transformation problems, and finally there's a task dealing
with validation of models resulting from the transformations.
The tasks build upon each other, but the transformation case project also
provides all intermediate models, thus making it possible to skip tasks that
are not suited for a particular tool, or for parallelizing the work among
members of participating teams.Comment: In Proceedings TTC 2013, arXiv:1311.753
Solving the TTC 2011 Reengineering Case with GReTL
This paper discusses the GReTL reference solution of the TTC 2011
Reengineering case. Given a Java syntax graph, a simple state machine model has
to be extracted. The submitted solution covers both the core task and the two
extension tasks.Comment: In Proceedings TTC 2011, arXiv:1111.440
Saying Hello World with GReTL - A Solution to the TTC 2011 Instructive Case
This paper discusses the GReTL solution of the TTC 2011 Hello World case. The
submitted solution covers all tasks including the optional ones.Comment: In Proceedings TTC 2011, arXiv:1111.440
A Functional, Comprehensive and Extensible Multi-Platform Querying and Transformation Approach
This thesis is about a new model querying and transformation approach called FunnyQT which is realized as a set of APIs and embedded domain-specific languages (DSLs) in the JVM-based functional Lisp-dialect Clojure. Founded on a powerful model management API, FunnyQT provides querying services such as comprehensions, quantified expressions, regular path expressions, logic-based, relational model querying, and pattern matching. On the transformation side, it supports the definition of unidirectional model-to-model transformations, of in-place transformations, it supports defining bidirectional transformations, and it supports a new kind of co-evolution transformations that allow for evolving a model together with its metamodel simultaneously. Several properties make FunnyQT unique. Foremost, it is just a Clojure library, thus, FunnyQT queries and transformations are Clojure programs. However, most higher-level services are provided as task-oriented embedded DSLs which use Clojure's powerful macro-system to support the user with tailor-made language constructs important for the task at hand. Since queries and transformations are just Clojure programs, they may use any Clojure or Java library for their own purpose, e.g., they may use some templating library for defining model-to-text transformations. Conversely, like every Clojure program, FunnyQT queries and transformations compile to normal JVM byte-code and can easily be called from other JVM languages. Furthermore, FunnyQT is platform-independent and designed with extensibility in mind. By default, it supports the Eclipse Modeling Framework and JGraLab, and support for other modeling frameworks can be added with minimal effort and without having to modify the respective framework's classes or FunnyQT itself. Lastly, because FunnyQT is embedded in a functional language, it has a functional emphasis itself. Every query and every transformation compiles to a function which can be passed around, given to higher-order functions, or be parametrized with other functions
Program Understanding: A Reengineering Case for the Transformation Tool Contest
In Software Reengineering, one of the central artifacts is the source code of
the legacy system in question. In fact, in most cases it is the only definitive
artifact, because over the time the code has diverged from the original
architecture and design documents. The first task of any reengineering project
is to gather an understanding of the system's architecture. Therefore, a common
approach is to use parsers to translate the source code into a model conforming
to the abstract syntax of the programming language the system is implemented in
which can then be subject to querying. Despite querying, transformations can be
used to generate more abstract views on the system's architecture. This
transformation case deals with the creation of a state machine model out of a
Java syntax graph. It is derived from a task that originates from a real
reengineering project.Comment: In Proceedings TTC 2011, arXiv:1111.440
Solving the TTC 2011 Compiler Optimization Case with GReTL
This paper discusses the GReTL solution of the TTC 2011 Compiler Optimization
case. The submitted solution covers both the constant folding task and the
instruction selection task. The verifier for checking the validity of the graph
is also implemented, and some additional test graphs are provided as requested
by the extension.Comment: In Proceedings TTC 2011, arXiv:1111.440
Solving the TTC 2011 Reengineering Case with GrGen.NET
The challenge of the Reengineering Case is to extract a state machine model
out of the abstract syntax graph of a Java program. The extracted state machine
offers a reduced view on the full program graph and thus helps to understand
the program regarding the question of interest. We tackle this task employing
the general purpose graph rewrite system GrGen.NET (www.grgen.net).Comment: In Proceedings TTC 2011, arXiv:1111.440
Solving the TTC 2011 Reengineering Case with VIATRA2
The current paper presents a solution of the Program Understanding: A
Reengineering Case for the Transformation Tool Contest using the VIATRA2 model
transformation tool.Comment: In Proceedings TTC 2011, arXiv:1111.440
Solving the TTC 2011 Reengineering Case with Henshin
This paper presents the Henshin solution to the Model Transformations for
Program Understanding case study as part of the Transformation Tool Contest
2011.Comment: In Proceedings TTC 2011, arXiv:1111.440
Solving the TTC 2011 Reengineering Case with MOLA and Higher-Order Transformations
The Reengineering Case of the Transformation Tool Contest 2011 deals with
automatic extraction of state machine from Java source code. The transformation
task involves complex, non-local matching of model elements. This paper
contains the solution of the task using model transformation language MOLA. The
MOLA solution uses higher-order transformations (HOT-s) to generate a part of
the required MOLA program. The described HOT approach allows creating reusable,
complex model transformation libraries for generic tasks without modifying an
implementation of a model transformation language. Thus model transformation
users who are not the developers of the language can achieve the desired
functionality more easily.Comment: In Proceedings TTC 2011, arXiv:1111.440